package grpc.htsoft.DataBase;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
//@javax.annotation.Generated(
//    value = "by gRPC proto compiler (version 1.52.1)",
//    comments = "Source: DataBase.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class DBGreeterGrpc {

  private DBGreeterGrpc() {}

  public static final String SERVICE_NAME = "HT_GRPC.DBGreeter";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo,
      grpc.htsoft.DataBase.Row> getGetRowMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetRow",
      requestType = grpc.htsoft.DataBase.DBInfo.class,
      responseType = grpc.htsoft.DataBase.Row.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo,
      grpc.htsoft.DataBase.Row> getGetRowMethod() {
    io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo, grpc.htsoft.DataBase.Row> getGetRowMethod;
    if ((getGetRowMethod = DBGreeterGrpc.getGetRowMethod) == null) {
      synchronized (DBGreeterGrpc.class) {
        if ((getGetRowMethod = DBGreeterGrpc.getGetRowMethod) == null) {
          DBGreeterGrpc.getGetRowMethod = getGetRowMethod =
              io.grpc.MethodDescriptor.<grpc.htsoft.DataBase.DBInfo, grpc.htsoft.DataBase.Row>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetRow"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.DBInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.Row.getDefaultInstance()))
              .setSchemaDescriptor(new DBGreeterMethodDescriptorSupplier("GetRow"))
              .build();
        }
      }
    }
    return getGetRowMethod;
  }

  private static volatile io.grpc.MethodDescriptor<grpc.htsoft.DataBase.Row,
      grpc.htsoft.DataBase.Row> getSaveRowMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SaveRow",
      requestType = grpc.htsoft.DataBase.Row.class,
      responseType = grpc.htsoft.DataBase.Row.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<grpc.htsoft.DataBase.Row,
      grpc.htsoft.DataBase.Row> getSaveRowMethod() {
    io.grpc.MethodDescriptor<grpc.htsoft.DataBase.Row, grpc.htsoft.DataBase.Row> getSaveRowMethod;
    if ((getSaveRowMethod = DBGreeterGrpc.getSaveRowMethod) == null) {
      synchronized (DBGreeterGrpc.class) {
        if ((getSaveRowMethod = DBGreeterGrpc.getSaveRowMethod) == null) {
          DBGreeterGrpc.getSaveRowMethod = getSaveRowMethod =
              io.grpc.MethodDescriptor.<grpc.htsoft.DataBase.Row, grpc.htsoft.DataBase.Row>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SaveRow"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.Row.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.Row.getDefaultInstance()))
              .setSchemaDescriptor(new DBGreeterMethodDescriptorSupplier("SaveRow"))
              .build();
        }
      }
    }
    return getSaveRowMethod;
  }

  private static volatile io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo,
      grpc.htsoft.DataBase.DataSet> getGetDataSetMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetDataSet",
      requestType = grpc.htsoft.DataBase.DBInfo.class,
      responseType = grpc.htsoft.DataBase.DataSet.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo,
      grpc.htsoft.DataBase.DataSet> getGetDataSetMethod() {
    io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo, grpc.htsoft.DataBase.DataSet> getGetDataSetMethod;
    if ((getGetDataSetMethod = DBGreeterGrpc.getGetDataSetMethod) == null) {
      synchronized (DBGreeterGrpc.class) {
        if ((getGetDataSetMethod = DBGreeterGrpc.getGetDataSetMethod) == null) {
          DBGreeterGrpc.getGetDataSetMethod = getGetDataSetMethod =
              io.grpc.MethodDescriptor.<grpc.htsoft.DataBase.DBInfo, grpc.htsoft.DataBase.DataSet>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetDataSet"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.DBInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.DataSet.getDefaultInstance()))
              .setSchemaDescriptor(new DBGreeterMethodDescriptorSupplier("GetDataSet"))
              .build();
        }
      }
    }
    return getGetDataSetMethod;
  }

  private static volatile io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo,
      grpc.htsoft.DataBase.Reply> getSetDataSetMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SetDataSet",
      requestType = grpc.htsoft.DataBase.DBInfo.class,
      responseType = grpc.htsoft.DataBase.Reply.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo,
      grpc.htsoft.DataBase.Reply> getSetDataSetMethod() {
    io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo, grpc.htsoft.DataBase.Reply> getSetDataSetMethod;
    if ((getSetDataSetMethod = DBGreeterGrpc.getSetDataSetMethod) == null) {
      synchronized (DBGreeterGrpc.class) {
        if ((getSetDataSetMethod = DBGreeterGrpc.getSetDataSetMethod) == null) {
          DBGreeterGrpc.getSetDataSetMethod = getSetDataSetMethod =
              io.grpc.MethodDescriptor.<grpc.htsoft.DataBase.DBInfo, grpc.htsoft.DataBase.Reply>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetDataSet"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.DBInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.Reply.getDefaultInstance()))
              .setSchemaDescriptor(new DBGreeterMethodDescriptorSupplier("SetDataSet"))
              .build();
        }
      }
    }
    return getSetDataSetMethod;
  }

  private static volatile io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo,
      grpc.htsoft.DataBase.Reply> getSaveDataSetMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "SaveDataSet",
      requestType = grpc.htsoft.DataBase.DBInfo.class,
      responseType = grpc.htsoft.DataBase.Reply.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo,
      grpc.htsoft.DataBase.Reply> getSaveDataSetMethod() {
    io.grpc.MethodDescriptor<grpc.htsoft.DataBase.DBInfo, grpc.htsoft.DataBase.Reply> getSaveDataSetMethod;
    if ((getSaveDataSetMethod = DBGreeterGrpc.getSaveDataSetMethod) == null) {
      synchronized (DBGreeterGrpc.class) {
        if ((getSaveDataSetMethod = DBGreeterGrpc.getSaveDataSetMethod) == null) {
          DBGreeterGrpc.getSaveDataSetMethod = getSaveDataSetMethod =
              io.grpc.MethodDescriptor.<grpc.htsoft.DataBase.DBInfo, grpc.htsoft.DataBase.Reply>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SaveDataSet"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.DBInfo.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  grpc.htsoft.DataBase.Reply.getDefaultInstance()))
              .setSchemaDescriptor(new DBGreeterMethodDescriptorSupplier("SaveDataSet"))
              .build();
        }
      }
    }
    return getSaveDataSetMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static DBGreeterStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<DBGreeterStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<DBGreeterStub>() {
        @java.lang.Override
        public DBGreeterStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new DBGreeterStub(channel, callOptions);
        }
      };
    return DBGreeterStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static DBGreeterBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<DBGreeterBlockingStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<DBGreeterBlockingStub>() {
        @java.lang.Override
        public DBGreeterBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new DBGreeterBlockingStub(channel, callOptions);
        }
      };
    return DBGreeterBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static DBGreeterFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<DBGreeterFutureStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<DBGreeterFutureStub>() {
        @java.lang.Override
        public DBGreeterFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new DBGreeterFutureStub(channel, callOptions);
        }
      };
    return DBGreeterFutureStub.newStub(factory, channel);
  }

  /**
   */
  public static abstract class DBGreeterImplBase implements io.grpc.BindableService {

    /**
     * <pre>
     * Sends a greeting
     *  rpc SayHello (HelloRequest) returns (HelloReply) {}
     *  rpc GetUser (User) returns (UserReply) {}
     *  rpc GetUser2 (User) returns (User){}
     *  rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}
     *获得某行
     * </pre>
     */
    public void getRow(grpc.htsoft.DataBase.DBInfo request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Row> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetRowMethod(), responseObserver);
    }

    /**
     * <pre>
     *保存某行
     * </pre>
     */
    public void saveRow(grpc.htsoft.DataBase.Row request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Row> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSaveRowMethod(), responseObserver);
    }

    /**
     * <pre>
     *获取dataset
     * </pre>
     */
    public void getDataSet(grpc.htsoft.DataBase.DBInfo request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.DataSet> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetDataSetMethod(), responseObserver);
    }

    /**
     * <pre>
     *设置dataset
     * </pre>
     */
    public void setDataSet(grpc.htsoft.DataBase.DBInfo request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Reply> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetDataSetMethod(), responseObserver);
    }

    /**
     * <pre>
     *保存dataset
     * </pre>
     */
    public void saveDataSet(grpc.htsoft.DataBase.DBInfo request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Reply> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSaveDataSetMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getGetRowMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                grpc.htsoft.DataBase.DBInfo,
                grpc.htsoft.DataBase.Row>(
                  this, METHODID_GET_ROW)))
          .addMethod(
            getSaveRowMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                grpc.htsoft.DataBase.Row,
                grpc.htsoft.DataBase.Row>(
                  this, METHODID_SAVE_ROW)))
          .addMethod(
            getGetDataSetMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                grpc.htsoft.DataBase.DBInfo,
                grpc.htsoft.DataBase.DataSet>(
                  this, METHODID_GET_DATA_SET)))
          .addMethod(
            getSetDataSetMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                grpc.htsoft.DataBase.DBInfo,
                grpc.htsoft.DataBase.Reply>(
                  this, METHODID_SET_DATA_SET)))
          .addMethod(
            getSaveDataSetMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                grpc.htsoft.DataBase.DBInfo,
                grpc.htsoft.DataBase.Reply>(
                  this, METHODID_SAVE_DATA_SET)))
          .build();
    }
  }

  /**
   */
  public static final class DBGreeterStub extends io.grpc.stub.AbstractAsyncStub<DBGreeterStub> {
    private DBGreeterStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected DBGreeterStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new DBGreeterStub(channel, callOptions);
    }

    /**
     * <pre>
     * Sends a greeting
     *  rpc SayHello (HelloRequest) returns (HelloReply) {}
     *  rpc GetUser (User) returns (UserReply) {}
     *  rpc GetUser2 (User) returns (User){}
     *  rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}
     *获得某行
     * </pre>
     */
    public void getRow(grpc.htsoft.DataBase.DBInfo request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Row> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetRowMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *保存某行
     * </pre>
     */
    public void saveRow(grpc.htsoft.DataBase.Row request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Row> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSaveRowMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *获取dataset
     * </pre>
     */
    public void getDataSet(grpc.htsoft.DataBase.DBInfo request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.DataSet> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetDataSetMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *设置dataset
     * </pre>
     */
    public void setDataSet(grpc.htsoft.DataBase.DBInfo request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Reply> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSetDataSetMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     * <pre>
     *保存dataset
     * </pre>
     */
    public void saveDataSet(grpc.htsoft.DataBase.DBInfo request,
        io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Reply> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getSaveDataSetMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class DBGreeterBlockingStub extends io.grpc.stub.AbstractBlockingStub<DBGreeterBlockingStub> {
    private DBGreeterBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected DBGreeterBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new DBGreeterBlockingStub(channel, callOptions);
    }

    /**
     * <pre>
     * Sends a greeting
     *  rpc SayHello (HelloRequest) returns (HelloReply) {}
     *  rpc GetUser (User) returns (UserReply) {}
     *  rpc GetUser2 (User) returns (User){}
     *  rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}
     *获得某行
     * </pre>
     */
    public grpc.htsoft.DataBase.Row getRow(grpc.htsoft.DataBase.DBInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetRowMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     *保存某行
     * </pre>
     */
    public grpc.htsoft.DataBase.Row saveRow(grpc.htsoft.DataBase.Row request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSaveRowMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     *获取dataset
     * </pre>
     */
    public grpc.htsoft.DataBase.DataSet getDataSet(grpc.htsoft.DataBase.DBInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetDataSetMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     *设置dataset
     * </pre>
     */
    public grpc.htsoft.DataBase.Reply setDataSet(grpc.htsoft.DataBase.DBInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSetDataSetMethod(), getCallOptions(), request);
    }

    /**
     * <pre>
     *保存dataset
     * </pre>
     */
    public grpc.htsoft.DataBase.Reply saveDataSet(grpc.htsoft.DataBase.DBInfo request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getSaveDataSetMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class DBGreeterFutureStub extends io.grpc.stub.AbstractFutureStub<DBGreeterFutureStub> {
    private DBGreeterFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected DBGreeterFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new DBGreeterFutureStub(channel, callOptions);
    }

    /**
     * <pre>
     * Sends a greeting
     *  rpc SayHello (HelloRequest) returns (HelloReply) {}
     *  rpc GetUser (User) returns (UserReply) {}
     *  rpc GetUser2 (User) returns (User){}
     *  rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}
     *获得某行
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<grpc.htsoft.DataBase.Row> getRow(
        grpc.htsoft.DataBase.DBInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetRowMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     *保存某行
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<grpc.htsoft.DataBase.Row> saveRow(
        grpc.htsoft.DataBase.Row request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSaveRowMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     *获取dataset
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<grpc.htsoft.DataBase.DataSet> getDataSet(
        grpc.htsoft.DataBase.DBInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetDataSetMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     *设置dataset
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<grpc.htsoft.DataBase.Reply> setDataSet(
        grpc.htsoft.DataBase.DBInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSetDataSetMethod(), getCallOptions()), request);
    }

    /**
     * <pre>
     *保存dataset
     * </pre>
     */
    public com.google.common.util.concurrent.ListenableFuture<grpc.htsoft.DataBase.Reply> saveDataSet(
        grpc.htsoft.DataBase.DBInfo request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getSaveDataSetMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_GET_ROW = 0;
  private static final int METHODID_SAVE_ROW = 1;
  private static final int METHODID_GET_DATA_SET = 2;
  private static final int METHODID_SET_DATA_SET = 3;
  private static final int METHODID_SAVE_DATA_SET = 4;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final DBGreeterImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(DBGreeterImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_GET_ROW:
          serviceImpl.getRow((grpc.htsoft.DataBase.DBInfo) request,
              (io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Row>) responseObserver);
          break;
        case METHODID_SAVE_ROW:
          serviceImpl.saveRow((grpc.htsoft.DataBase.Row) request,
              (io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Row>) responseObserver);
          break;
        case METHODID_GET_DATA_SET:
          serviceImpl.getDataSet((grpc.htsoft.DataBase.DBInfo) request,
              (io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.DataSet>) responseObserver);
          break;
        case METHODID_SET_DATA_SET:
          serviceImpl.setDataSet((grpc.htsoft.DataBase.DBInfo) request,
              (io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Reply>) responseObserver);
          break;
        case METHODID_SAVE_DATA_SET:
          serviceImpl.saveDataSet((grpc.htsoft.DataBase.DBInfo) request,
              (io.grpc.stub.StreamObserver<grpc.htsoft.DataBase.Reply>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class DBGreeterBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    DBGreeterBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return grpc.htsoft.DataBase.DataBaseProto.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("DBGreeter");
    }
  }

  private static final class DBGreeterFileDescriptorSupplier
      extends DBGreeterBaseDescriptorSupplier {
    DBGreeterFileDescriptorSupplier() {}
  }

  private static final class DBGreeterMethodDescriptorSupplier
      extends DBGreeterBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    DBGreeterMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (DBGreeterGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new DBGreeterFileDescriptorSupplier())
              .addMethod(getGetRowMethod())
              .addMethod(getSaveRowMethod())
              .addMethod(getGetDataSetMethod())
              .addMethod(getSetDataSetMethod())
              .addMethod(getSaveDataSetMethod())
              .build();
        }
      }
    }
    return result;
  }
}
